#include "EEntityManager.h"
#include "EEntity.h"

#include "cCPP.h"
namespace engine
{
//------------------------------------------------------------
// EEntityGroup
//------------------------------------------------------------
EEntityGroup::EEntityGroup( EEntity::_eGroupType eType ) :
m_eType( eType )
{
}

//------------------------------------------------------------
EEntityGroup::~EEntityGroup( )
{
  if( m_bGameStarted )
    endGame();
  EEntityVector::iterator it;
  for( it = m_vEntities.begin(); it != m_vEntities.end(); ++it )
  {
    delete (*it);
  }
  m_vEntities.clear();
}

//------------------------------------------------------------
bool EEntityGroup::update( const EGameTime& time )
{
  EEntityVector::iterator it;
  for( it = m_vEntities.begin(); it != m_vEntities.end(); ++it )
  {
    cTEST( (*it)->update( time ) );
  }
  return true;
}

//------------------------------------------------------------
bool EEntityGroup::startGame()
{
  EEntityVector::iterator it;
  for( it = m_vEntities.begin(); it != m_vEntities.end(); ++it )
  {
    cTEST( (*it)->startGame( ) );
  }
  m_bGameStarted = true;

  return true;
}

//------------------------------------------------------------
bool EEntityGroup::updateGame( const EGameTime& time )
{
  EEntityVector::iterator it;
  for( it = m_vEntities.begin(); it != m_vEntities.end(); ++it )
  {
    cTEST( (*it)->updateGame( time ) );
  }
  return true;
}

//------------------------------------------------------------
bool EEntityGroup::endGame()
{
  EEntityVector::iterator it;
  for( it = m_vEntities.begin(); it != m_vEntities.end(); ++it )
  {
    cTEST( (*it)->endGame( ) );
  }
  m_bGameStarted = false;

  return true;
}

//------------------------------------------------------------
bool EEntityGroup::addEntity(EEntity& entity )
{
  m_vEntities.push_back( &entity );

  return true;
}
//------------------------------------------------------------
// EEntityManager
//------------------------------------------------------------
EEntityManager::EEntityManager()
{
  initGroups();
}

//------------------------------------------------------------
EEntityManager::~EEntityManager()
{
  vector<EEntityGroup*>::iterator it;
  for( it = m_vGroups.begin(); it != m_vGroups.end(); ++it )
  {
    delete (*it);
  }
  m_vGroups.clear();
}

//------------------------------------------------------------
bool EEntityManager::initGroups()
{
  EEntityGroup* pGroup = NULL;

  for( int id=0; id<EEntity::ENTITY_GROUP_COUNT; ++id )
  {
    pGroup = new EEntityGroup( static_cast<EEntity::_eGroupType>( id ) );
    cTEST( pGroup != NULL );
    m_vGroups.push_back( pGroup );
  }

  return true;
}

//------------------------------------------------------------
bool EEntityManager::update( const EGameTime& time )
{
  vector<EEntityGroup*>::iterator it;
  for( it = m_vGroups.begin(); it != m_vGroups.end(); ++it )
  {
    cTEST( (*it)->update( time ) );
  }
  return true;
}

//------------------------------------------------------------
bool EEntityManager::startGame()
{
  vector<EEntityGroup*>::iterator it;
  for( it = m_vGroups.begin(); it != m_vGroups.end(); ++it )
  {
    cTEST( (*it)->startGame( ) );
  }

  return true;
}

//------------------------------------------------------------
bool EEntityManager::updateGame( const EGameTime& time )
{
  vector<EEntityGroup*>::iterator it;
  for( it = m_vGroups.begin(); it != m_vGroups.end(); ++it )
  {
    cTEST( (*it)->updateGame( time ) );
  }
  return true;
}

//------------------------------------------------------------
bool EEntityManager::endGame()
{
  vector<EEntityGroup*>::iterator it;
  for( it = m_vGroups.begin(); it != m_vGroups.end(); ++it )
  {
    cTEST( (*it)->endGame( ) );
  }

  return true;
}

//------------------------------------------------------------
bool EEntityManager::addEntity( EEntity::_eGroupType eGroupType, EEntity& entity )
{
  cASSERT( (uint)eGroupType < m_vGroups.size() );

  EEntityGroup* pGroup = m_vGroups[ static_cast<int>(eGroupType) ];
  cASSERT( pGroup != NULL );
  cTEST( pGroup->addEntity( entity ) );

  return true;
}

//------------------------------------------------------------
EEntityGroup& EEntityManager::getEntityGroup(EEntity::_eGroupType eGroupType ) const
{
  EEntityGroup* pGroup = m_vGroups[ static_cast<int>(eGroupType) ];
  cASSERT( pGroup != NULL );
  return *pGroup;
}

} // end namespace 